<!DOCTYPE html>
<html lang="en">

<head>
    <meta charset="UTF-8">
    <meta http-equiv="X-UA-Compatible" content="IE=edge">
    <meta name="viewport" content="width=device-width, initial-scale=1.0">
    <title>Document</title>
</head>

<body>

</body>

</html>
<script>
    //以下两个方法可以做累计
    // 1.IndexOf()   lastIndexOf 返回要查找的项在数组中的索引位置，没找到返回-1
    //两个参数 ：1要查找的项
    //         2.表示查找起点位置的索引
    var arr1 = ['a', 'b', 'c', 'd', 'a', 'c', 'e']
    // console.log(arr1.indexOf('c'))      //2
    // console.log(arr1.indexOf('c',5))    //5
    // console.log(arr1.indexOf('a'))      //0
    // console.log(arr1.indexOf('a',2))    //4
    // console.log(arr1.indexOf('g'))      //-1  因为不存在
    // console.log(arr1.lastIndexOf('c'))    //5



    //数组去重(用indexof的算法)
    // var newarr=[]
    // for(i=0;i<arr1.length;i++){
    //     if (newarr.indexOf(arr1[i])===-1) {
    //         newarr.push(arr1[i])
    //     }   
    // }
    // console.log(newarr)          //(5) ["a", "b", "c", "d", "e"]

    // 2.includes()   返回要查找的项在数组中是否存在，返回布尔值，存在返回true，不存在返回false.
    // console.log(arr1.includes('b'))          //true
    // console.log(arr1.includes('h'))         //false


    //数组去重(用includes的算法)
    // var newarr=[]
    // for(i=0;i<arr1.length;i++){
    //     if (!newarr.includes(arr1[i])){
    //         newarr.push(arr1[i])
    //     }   
    // }
    // console.log(newarr)              // (5) ["a", "b", "c", "d", "e"]


    //3.迭代方法  (重复反馈过程的活动，自带遍历)   foreach 没有返回值，map和filter有返回值
    //***forEach() 对数组中的每一项运行给定函数，这个方法没有返回值  参数1：是一个函数，函数做参数，函数里面还有三个参数，value(数组项的值),index(数组项的索引),array(数组本身)
    var arr2 = ['100', '200', '300', '400', '500', '600', '700']
    // arr2.forEach(function(value,index,array){
    //     // console.log(value)
    // console.log(index)
    // console.log(array)
    // console.log(index+':'+value+'--'+array)  //下面是打印的结果
    // })
    //  0:100--100,200,300,400,500,600,700
    //  1:200--100,200,300,400,500,600,700
    //  2:300--100,200,300,400,500,600,700
    //  3:400--100,200,300,400,500,600,700
    //  4:500--100,200,300,400,500,600,700
    //  5:600--100,200,300,400,500,600,700
    //  6:700--100,200,300,400,500,600,700

    //数组去重(用forEach的算法)
    // var newarr=[]
    // arr1.forEach(function(value,index){   
    //      if(!newarr.includes(value))
    //         newarr.push(value)})   //   (5) ["a", "b", "c", "d", "e"]

    // console.log(newarr)


    //***map()  映射  一一对应    函数做参数   有返回值，返回值是新的数组   
    //对数组中的每一项运行给定函数，返回每次函数调用的结果组成的数组，返回的就是数组，不考虑true or false
    //输出对应的结果，每一项都有一个对应的结果，不一定是true or false
    // var newarr=arr2.map(function(value,index,array){ 
    //                          return value>200;
    // }) 
    // console.log(newarr)   //   (7) [false, false, true, true, true, true, true]


    // var newarr=arr2.map(function(value,index,array){ 
    //                          return value/10;
    // }) 
    // console.log(newarr)   //    (7) [10, 20, 30, 40, 50, 60, 70]



    // var arr1=['a','b','c','d','a','c','e']
    // var newarr=arr1.map(function(value,index){
    //     return arr1.indexOf(value)===index   
    // })
    // console.log(newarr)    //(7) [true, true, true, true, false, false, true]



    //***filter()对数组中的每一项运行给定函数，返回该函数结果为true的项的数组项   filter 输出的是 map返回值为true的项
    //输出满足条件的值
    //去重（filter的算法）
    // var arr1=['a','b','c','d','a','c','e']
    // var newarr=arr1.filter(function(value,index){
    //     return arr1.indexOf(value)===index
    // })
    // console.log(newarr)   //  (5) ["a", "b", "c", "d", "e"]


    //4.every()  对数组中的每一项运行给定函数，如果该函数对每一项都返回true，则返回true   相当于逻辑与 &&
    // var result=arr2.every(function(value,index,array){ 
    //                           return value>200;
    //  }) 
    //  console.log(result)        //false

    // var result=arr2.every(function(value,index,array){ 
    //                           return typeof value ==='string';
    //  }) 
    //  console.log(result)        //

    //5.some() 对数组中的每一项运行给定函数，如果该函数对任意一项返回true，则返回true   相当于逻辑或 ||
    // var result=arr2.some(function(value,index,array){ 
    //                           return value>200;
    //  }) 
    //  console.log(result)     //true



    //归并方法--reduce()   reduceRight()
    //迭代： 每一次迭代得到的结果回作为下一次迭代的初始值，而这两个方法都会迭代数组的所有项，然后构建一个最终返回的值

    //reduce()  方法从数组的第一项开始，逐个遍历到最后      参数：   prev:前一个值   curr：当前值
    //只有一个函数做参数的时候
    var arr3 = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
    // var result = arr3.reduce(function (prev, curr, index, array) {
    //     console.log(prev)     //第一次指向数组的第一项  1，后面都是前面迭代的结果
    //     console.log(curr)       //表示从数组的第二项开始的值  2-10
    //     return prev + curr

    // })
    // console.log(result)    //55  =  1+2+3+...+10

    //有两个参数的时候，参数1是函数u，参数2是迭代的初始值
    // var result=arr3.reduce(function(prev,curr,index,arry){
    //     console.log(prev)                       //第一次指向迭代的初始值，100，后面都是前面迭代的结果。
    //     console.log(curr)   
    //     return prev+curr                  //从数组的第一项开始的值 1-10
    // },100) 
    // console.log(result)    // 155  = 1+2+3+...+10 +100初始值


    // reduceRight()   //与reduce用法相似
    // var result = arr3.reduceRight(function (prev, curr, index, arry) {
    //     console.log(prev)          //第一次指向迭代的初始值，100，后面都是前面迭代的结果。              
    //     console.log(curr)          //从数组的最后一项开始的值 10-1
    //     return prev + curr
    // }, 100)
    // console.log(result)
</script>